References
install.packages("shiny"); library(shiny) = install/load shiny packageui.R - controls appearance/all style elementsserver.R - controls functionsrunApp() executes the Shiny application
runApp(display.mode = 'showcase') = displays the code from ui.R and server.R and highlights what is being executed depending on the inputs"," must be included ONLY INBETWEEN objects/functions on the same level www directory with an index.html file enclosed can be used instead of ui.R
shiny-text-output, shiny-plot-output, or shiny-html-output) library(shiny) = first line, loads the shiny packageshinyUI() = shiny UI wrapper, contains sub-methods to create panels/parts/viewable objecttitlePanel("title") = specifies a titlepageWithSideBar() = creates page with main/side bar divisionheaderPanel("title") = specifies header of the pagesidebarLayout() = specifies the sidebar layoutsideBarPanel() = specifies parameters/objects in the side bar (on the left)mainPanel() = specifies parameters/objects in the main panel (on the right)shinyUI(fluidpage()) (tutorial) <– produces responsive web pages
fluidRow() = creates row of content with width 12 that can be subdivided into columns
column(4, ...) = creates a column of width 4 within the fluid rowstyle = "CSS" = can be used as the last element of the column to specify additional styleabsolutePanel(top=0, left=0, right=0) = used to produce floating panels on top of the page (documentation)
fixed = TRUE = panel will not scroll with page, which means the panel will always stay in the same position as you scroll through the pagedraggable = TRUE = make panel movable by the usertop = 40 / bottom = 50 = position from the top/bottom edge of the browser window
top = 0, bottom = 0 = creates panel that spans the entire vertical length of windowleft = 40 / right = 50 = position from the left/right edge of the browser window
top = 0, bottom = 0 = creates panel that spans the entire horizontal length of windowheight = 30 / width = 40 = specifies the height/width of the panelstyle = "opacity:0.92; z-index = 100" = makes panel transparent and ensures the panel is always the top-most elementh1/2/3/4/5/6('heading') = creates heading for the panelp('pargraph') = creates regular text/paragrapha() = hyperlinkspan() = group inline-elementscode('code') = renders code format on the pagebr() = inserts line breaktags$hr() = inserts horizontal linetags$ol()/ tags$ul() = initiates ordered/unordered listdiv( ... , style = "CSS Code") / span( ... , style = "CSS Code") = used to add additional style to particular parts of the app
div should be used for a section/block, span should be used for a specific part/inlinewithMathJax() = add this element to allow Shiny to process LaTeX
\\(LaTeX\\)$$LaTeX$$?builder for more detailstextInput(inputId = "id", label = "textLabel") = creates a plain text input field
inputId = field identifierlabel = text that appear above/before a fieldnumericInput('HTMLlabel', 'printedLabel', value = 0, min = 0, max = 10, step = 1) = create a number input field with incrementer (up/down arrows)
'HTMLLabel' = name given to the field, not printed, and can be called'printedLabel' = text that shows up above the input box explaining the fieldvalue = default numeric value that the field should take; 0 is an examplemin = minimum value that can be set in the field (if a smaller value is manually entered, then the value becomes the minimum specified once user clicks away from the field)max = max value that can be set in the fieldstep = increments for the up/down arrows?numericInputcheckboxGroupInput("id2", "Checkbox",choices = c("Value 1" = "1", ...), selected = "1", inline = TRUE) = creates a series of checkboxes
"id2", "Checkbox" = field identifier/labelchoices = list of checkboxes and their labels
"checkboxName" = "fieldIdentifier"fieldIdentifier should generally be different from checkbox to checkbox, so we can properly identify the responses selected = specifies the checkboxes that should be selected by default; uses fieldIndentifier valuesinline = whether the options should be displayed inlinedateInput("fieldID", "fieldLabel") = creates a selectable date field (dropdown calendar/date picker automatically generated)
"fieldID" = field identifier"fieldLabel" = text/name displayed above fields?dateInputsubmitButton("Submit") = creates a submit button that updates the output/calculations only when the user submits the new inputs (default behavior = all changes update reactively/in real time)actionButton(inputId = "goButton", label = "test") = creates a button with the specified label and id
sliderInput("id", "label", value = 70, min = 62, max = 74, 0.05) = creates a slider for input
numericInput and more information can be found ?sliderInputoutput element in server.R to render their value textOutput("fieldId", inline = FALSE) = prints the value of the variable/field in text format
inline = TRUE = inserts the result inline with the HTML elementinline = FALSE = inserts the result in block code formatverbatimTextOutput("fieldId") = prints out the value of the specified field defined in server.RplotOutput('fieldId') = plots the output (‘sampleHist’ for example) created from server.R scriptoutput$test <- renderText({input$goButton}); isolate(paste(input$t1, input$2))}) = isolate action executes when the button is pressed
if (input$goButton == 1){ Conditional statements } = create different behavior depending on the number of times the button is pressedtabsetPanel() = specifies a group of tabstabPanel() = specifies the contents of an individual tabbrush argument in plotOutput() on the ui.R side, and then using the brushedPoints() function on the server.R side# basis app with sliders and plot
library(shiny)
shinyUI(fluidPage(
titlePanel("Plot Random Numbers"),
sidebarLayout(
sidebarPanel(
numericInput("numeric", "How Many Random Numbers Should be Plotted?",
value = 1000, min = 1, max = 1000, step = 1),
sliderInput("sliderX", "Pick Minimum and Maximum X Values",
-100, 100, value = c(-50, 50)),
sliderInput("sliderY", "Pick Minimum and Maximum Y Values",
-100, 100, value = c(-50, 50)),
checkboxInput("show_xlab", "Show/Hide X Axis Label", value = TRUE),
checkboxInput("show_ylab", "Show/Hide Y Axis Label", value = TRUE),
checkboxInput("show_title", "Show/Hide Title")
),
mainPanel(
h3("Graph of Random Points"),
plotOutput("plot1")
)
)
))library(shiny)
shinyUI(fluidPage(
titlePanel("Tabs!"),
sidebarLayout(
sidebarPanel(
textInput("box1", "Enter Tab 1 Text:", value = "Tab 1!"),
textInput("box2", "Enter Tab 2 Text:", value = "Tab 2!"),
textInput("box3", "Enter Tab 3 Text:", value = "Tab 3!")
),
mainPanel(
tabsetPanel(type = "tabs",
tabPanel("Tab 1", br(), textOutput("out1")),
tabPanel("Tab 2", br(), textOutput("out2")),
tabPanel("Tab 2", br(), textOutput("out3"))
)
)
)
))library(shiny)
shinyUI(fluidPage(
titlePanel("Visualize Many Models"),
sidebarLayout(
sidebarPanel(
h3("Slope"),
textOutput("slopeOut"),
h3("Intercept"),
textOutput("intOut")
),
mainPanel(
plotOutput("plot1", brush = brushOpts(id = "brush1"))
)
)
))# load shiny package
library(shiny)
# begin shiny UI
shinyUI(navbarPage("Shiny Project",
# create first tab
tabPanel("Documentation",
# load MathJax library so LaTeX can be used for math equations
withMathJax(), h3("Why is the Variance Estimator \\(S^2\\) divided by \\(n-1?\\)"),
# paragraph and bold text
p("The ", strong("sample variance")," can be calculated in ", strong(em("two")),
" different ways:",
"$$S^2 \\mbox{(unbiased)} = \\frac{\\sum_{i=1}^n (X_i - \\bar X)^2}{n-1}
~~~\\mbox{and}~~S^2\\mbox{(biased)}=\\frac{\\sum_{i=1}^n (X_i-\\bar X)^2}{n}$$",
"The unbiased calculation is most often used, as it provides a ",
strong(em("more accurate")), " estimate of population variance"),
# break used to space sections
br(), p("To show this empirically, we simulated the following in the ",
strong("Simulation Experiment"), " tab: "), br(),
# ordered list
tags$ol(
tags$li("Create population by drawing observations from values 1 to 20."),
tags$li("Draw a number of samples of specified size from the population"),
tags$li("Plot difference between sample and true population variance"),
tags$li("Show the effects of sample size vs accuracy of variance estimated")
)),
# second tab
tabPanel("Simulation Experiment",
# fluid row for space holders
fluidRow(
# fluid columns
column(4, div(style = "height: 150px")),
column(4, div(style = "height: 150px")),
column(4, div(style = "height: 150px"))),
# main content
fluidRow(
column(12,h4("We start by generating a population of ",
span(textOutput("population", inline = TRUE),
style = "color: red; font-size: 20px"),
" observations from values 1 to 20:"),
tags$hr(),htmlOutput("popHist"),
# additional style
style = "padding-left: 20px"
)
),
# absolute panel
absolutePanel(
# position attributes
top = 50, left = 0, right =0,
fixed = TRUE,
# panel with predefined background
wellPanel(
fluidRow(
# sliders
column(4, sliderInput("population", "Size of Population:",
min = 100, max = 500, value = 250),
p(strong("Population Variance: "),
textOutput("popVar", inline = TRUE))),
column(4, sliderInput("numSample", "Number of Samples:",
min = 100, max = 500, value = 300),
p(strong("Sample Variance (biased): "),
textOutput("biaVar", inline = TRUE))),
column(4, sliderInput("sampleSize", "Size of Samples:",
min = 2, max = 15, value = 10),
p(strong("Sample Variance (unbiased): "),
textOutput("unbiaVar", inline = TRUE)))),
style = "opacity: 0.92; z-index: 100;"
))
)
))library() calls to load packages/data<<- operator should be used to assign values to variables in the parent environmentx <<- x + 1 will define x to be the sum of 1 and the value of x (defined in the parent environment/working environment)shinyServer() = initiates the server function
function(input, output){} = defines a function that performs actions on the inputs user makes and produces an output objectreactive(function) = can be used to wrap functions/expressions to create reactive expressions
renderText({x()}) = returns value of x, “()” must be included (syntax)reactive() should be expressions that are subject to changeui.R insert a submit button via submitButton("Submit")server.R # start shinyServer
shinyServer(
# specify input/output function
function(input, output) {
# set x as a reactive function that adds 100 to input1
x <- reactive({as.numeric(input$text1)+100})
# set value of x to output object text1
output$text1 <- renderText({ x() })
# set value of x plus value of input object text2 to output object text1
output$text2 <- renderText({ x() + as.numeric(input$text2) })
})shinyServer()
output$oid1 <- renderPrint({input$id1}) = stores the user input value in field id1 and stores the rendered, printed text in the oid1 variable of the output object
renderPrint({expression}) = reactive function to render the specified expression{} is used to ensure the value is an expressionoid1 = variable in the output object that stores the result from the subsequent commandoutput$sampleHist <- renderPlot({code}) = stores plot generated by code into sampleHist variable
renderPlot({code}) = renders a plot generated by the enclosed R codeoutput$sampleGVisPlot <- renderGvis({code}) = renders Google Visualization object# basic app with sliders and plot
library(shiny)
shinyServer(function(input, output) {
output$plot1 <- renderPlot({
set.seed(2016-05-25)
number_of_points <- input$numeric
minX <- input$sliderX[1]
maxX <- input$sliderX[2]
minY <- input$sliderY[1]
maxY <- input$sliderY[2]
dataX <- runif(number_of_points, minX, maxX)
dataY <- runif(number_of_points, minY, maxY)
xlab <- ifelse(input$show_xlab, "X Axis", "")
ylab <- ifelse(input$show_ylab, "Y Axis", "")
main <- ifelse(input$show_title, "Title", "")
plot(dataX, dataY, xlab = xlab, ylab = ylab, main = main,
xlim = c(-100, 100), ylim = c(-100, 100))
})
})library(shiny)
shinyServer(function(input, output) {
output$out1 <- renderText(input$box1)
output$out2 <- renderText(input$box2)
output$out3 <- renderText(input$box3)
})library(shiny)
shinyServer(function(input, output) {
model <- reactive({
brushed_data <- brushedPoints(trees, input$brush1,
xvar = "Girth", yvar = "Volume")
if(nrow(brushed_data) < 2){
return(NULL)
}
lm(Volume ~ Girth, data = brushed_data)
})
output$slopeOut <- renderText({
if(is.null(model())){
"No Model Found"
} else {
model()[[1]][2]
}
})
output$intOut <- renderText({
if(is.null(model())){
"No Model Found"
} else {
model()[[1]][1]
}
})
output$plot1 <- renderPlot({
plot(trees$Girth, trees$Volume, xlab = "Girth",
ylab = "Volume", main = "Tree Measurements",
cex = 1.5, pch = 16, bty = "n")
if(!is.null(model())){
abline(model(), col = "blue", lwd = 2)
}
})
})# load libraries
library(shiny)
require(googleVis)
# begin shiny server
shinyServer(function(input, output) {
# define reactive parameters
pop<- reactive({sample(1:20, input$population, replace = TRUE)})
bootstrapSample<-reactive({sample(pop(),input$sampleSize*input$numSample,
replace = TRUE)})
popVar<- reactive({round(var(pop()),2)})
# print text through reactive funtion
output$biaVar <- renderText({
sample<- as.data.frame(matrix(bootstrapSample(), nrow = input$numSample,
ncol =input$sampleSize))
return(round(mean(rowSums((sample-rowMeans(sample))^2)/input$sampleSize), 2))
})
# google visualization histogram
output$popHist <- renderGvis({
popHist <- gvisHistogram(data.frame(pop()), options = list(
height = "300px",
legend = "{position: 'none'}", title = "Population Distribution",
subtitle = "samples randomly drawn (with replacement) from values 1 to 20",
histogram = "{ hideBucketItems: true, bucketSize: 2 }",
hAxis = "{ title: 'Values', maxAlternation: 1, showTextEvery: 1}",
vAxis = "{ title: 'Frequency'}"
))
return(popHist)
})
})runApp (requires R knowledge)runGist() or runGitHub() function to launch your appdevtools installed in R (install.packages("devtools"))devtools::install_github('rstudio/shinyapps'), which installs the shinyapps package from GitHubdeployApp() commandrunApp(display.mode = 'showcase') = highlights execution while running a shiny applicationcat = can be used to display output to stdout/R consolebrowser() = interrupts execution (tutorial)manipulate Packagemanipulate = package/function can be leveraged to create quick interactive graphics by allowing the user to vary the different variables to a model/calculationcreates sliders/checkbox/picker for the user (documentation)
Example
# load data and manipulate package
library(UsingR)
library(manipulate)
# plotting function
myHist <- function(mu){
# histogram
hist(galton$child,col="blue",breaks=100)
# vertical line to highlight the mean
lines(c(mu, mu), c(0, 150),col="red",lwd=5)
# calculate mean squared error
mse <- mean((galton$child - mu)^2)
# updates the mean value as the mean is changed by the user
text(63, 150, paste("mu = ", mu))
# updates the mean squared error value as the mean is changed by the user
text(63, 140, paste("MSE = ", round(mse, 2)))
}
# creates a slider to vary the mean for the histogram
manipulate(myHist(mu), mu = slider(62, 74, step = 0.5))miniUI package for creating user interfacesminiUI package comes in handy for its smaller graphical elementsminiPage() creates a small layoutgadgetTitleBar() provides a title bar with Done and Cancel buttonsrunGadget() runs the Shiny Gadget, taking ui and server as argumentslibrary(shiny)
library(miniUI)
myFirstGadget <- function() {
ui <- miniPage(
gadgetTitleBar("My First Gadget")
)
server <- function(input, output, session) {
# The Done button closes the app
observeEvent(input$done, {
stopApp()
})
}
runGadget(ui, server)
}
myFirstGadget()One of the advantages of Shiny Gadgets is that since Shiny Gadgets are functions they can take values as arguments and they can return values
library(shiny)
library(miniUI)
multiplyNumbers <- function(numbers1, numbers2) {
ui <- miniPage(
gadgetTitleBar("Multiply Two Numbers"),
miniContentPanel(
selectInput("num1", "First Number", choices=numbers1),
selectInput("num2", "Second Number", choices=numbers2)
)
)
server <- function(input, output, session) {
observeEvent(input$done, {
num1 <- as.numeric(input$num1)
num2 <- as.numeric(input$num2)
stopApp(num1 * num2)
})
}
runGadget(ui, server)
}
multiplyNumbers(1:10,1:10)brushedPoints() function, which is part of the shiny package.
?shiny::brushedPoints for more information)library(shiny)
library(miniUI)
pickTrees <- function() {
ui <- miniPage(
gadgetTitleBar("Select Points by Dragging your Mouse"),
miniContentPanel(
plotOutput("plot", height = "100%", brush = "brush")
)
)
server <- function(input, output, session) {
output$plot <- renderPlot({
plot(trees$Girth, trees$Volume, main = "Trees!",
xlab = "Girth", ylab = "Volume")
})
observeEvent(input$done, {
stopApp(brushedPoints(trees, input$brush,
xvar = "Girth", yvar = "Volume"))
})
}
runGadget(ui, server)
}
pickTrees()lattice plotting system)devtools must be installed first (install.packages("devtools"))require(devtools); install_github('rCharts', 'ramnathv') installs the rCharts package from GitHubrPlot = paneled scatter plotsmPlot = time series plot (similar to stock price charts)nPlot = stacked/grouped bar chartsn1 <- nplot(...)
n1$ + TAB in R Console brings up list of all functions contained in the objectn1$html() = prints out the HTML for the plotn1$save("filename.html") = saves result to a file named “filename.html”n1$print() = print out the JavaScriptn1$show("inline", include_assets = TRUE, cdn = F) = embed HTML/JS code directly with in Rmd file (for HTML output)
n1$publish('plotname', host = 'gist'/'rpubs') = publishes the plot under the specified plotname as a gist or to rpubsyaml ext_widgets : {rCharts: ["libraries/nvd3"]}cat('<iframe src="map3.html" width=100%, height=600></iframe>') to embed a map or chart form a saved file (saved with: map3$save('map3.html', cdn = TRUE))# load rCharts package
require(rCharts); library(datasets); library(knitr)
# create dataframe with HairEyeColor data
haireye = as.data.frame(HairEyeColor)
# create a nPlot object
n1 <- nPlot(Freq ~ Hair, group = 'Eye', type = 'multiBarChart',
data = subset(haireye, Sex == 'Male'))
# save the nPlot object to a html page
n1$show("inline", include_assets = TRUE, cdn = F)ggvis packageggvis is a data visualization package for R that lets you:
shiny’s infrastructure to publish interactive graphics usable from any browser (either within your company or to the world).%>%, to chain graphing functions
set_options(renderer = "canvas") = can be used to control what renderer the graphics is produced withmtcars %>% ggvis(~mpg, ~wt, fill = ~ as.factor(am)) %>% layer_points() %>% layer_smooths()# for HTML version
library(ggvis)
mtcars %>%
ggvis(~mpg, ~wt, fill = ~ as.factor(am)) %>%
layer_points() %>%
layer_smooths() %>%
set_options(renderer = "canvas")# for pdf version
library(ggvis)
mtcars %>%
ggvis(~mpg, ~wt, fill = ~ as.factor(am)) %>%
layer_points() %>%
layer_smooths()gvisMotionChartgvisGeoChartgvisTablegvisLineChartgvisColumnChartgvisTreeMapprint(chart, "chart") = prints the JavaScript for creating the interactive plot so it can be embedded in slidify/HTML document
print(chart) = prints HTML + JavaScript directlyop <- options(gvis.plot.tag='chart')
plot.gvis, so that only the chart component of the HTML file is written into the output fileplot(chart) can then be called to print the plots to HTMLoptions(gvis.plot.tag=NULL)print(chart, file="test.html") = stores code into a HTML filegvisMerge(chart1, chart2, horizontal = TRUE, tableOptions = "bgcolor = \"#CCCCCC\" cellspacing = 10) = combines the two plots into one horizontally (1 x 2 panel)
gvisMerge() can only combine TWO plots at a time horizontal = FALSE = combines plots vertically (TRUE for horizontal combination)tableOptions = ... = used to specify attributes of the combined plotdemo(googleVis) = demos how each of the plot worksgoogleVis with knitr you have to set results = "asis" in the code chunk optionsself_contained: no in the YAML header under html_document:# load googleVis package
suppressPackageStartupMessages(library(googleVis))
# set gvis.plot options to only return the chart
op <- options(gvis.plot.tag='chart')
# create initial data with x variable as "label" and y variable as "var1/var2"
df <- data.frame(label=c("US", "GB", "BR"), val1=c(1,3,4), val2=c(23,12,32))
# set up a gvisLineChart with x and y
Line <- gvisLineChart(df, xvar="label", yvar=c("val1","val2"),
# set options for the graph (list) - title and location of legend
options=list(title="Hello World", legend="bottom",
# set title text style
titleTextStyle="{color:'red', fontSize:18}",
# set vertical gridlines
vAxis="{gridlines:{color:'red', count:3}}",
# set horizontal axis title and style
hAxis="{title:'My Label', titleTextStyle:{color:'blue'}}",
# set plotting style of the data
series="[{color:'green', targetAxisIndex: 0},
{color: 'blue',targetAxisIndex:1}]",
# set vertical axis labels and formats
vAxes="[{title:'Value 1 (%)', format:'##,######%'},
{title:'Value 2 (\U00A3)'}]",
# set line plot to be smoothed and set width and height of the plot
curveType="function", width=500, height=300
))
# print the chart in JavaScript
plot(Line)G <- gvisGeoChart(Exports, "Country", "Profit",options=list(width=200, height=100))
T1 <- gvisTable(Exports,options=list(width=200, height=270))
M <- gvisMotionChart(Fruits, "Fruit", "Year", options=list(width=400, height=370))
GT <- gvisMerge(G,T1, horizontal=FALSE)
GTM <- gvisMerge(GT, M, horizontal=TRUE,tableOptions="bgcolor=\"#CCCCCC\" cellspacing=10")
plot(GTM)
|
|
If you want to share your visualizations on https://plot.ly/ you should make an account on their site
Example: Basic Scatterplot with coloring and sizing
library(plotly)
plot_ly(mtcars, x = ~wt, y = ~mpg, type = "scatter", mode="markers",
color = ~factor(cyl), size = ~hp)set.seed(2016-07-21)
temp <- rnorm(100, mean = 30, sd = 5)
pressue <- rnorm(100)
dtime <- 1:100
plot_ly(x = ~temp, y = ~pressue, z = ~dtime,
type = "scatter3d", color = ~temp)library(tidyr)
library(dplyr)
data("EuStockMarkets")
stocks <- as.data.frame(EuStockMarkets) %>%
gather(index, price) %>%
mutate(time = rep(time(EuStockMarkets), 4))
plot_ly(stocks, x = ~time, y = ~price, color = ~index, type = "scatter", mode = "lines")plot_ly(x = ~precip, type = "histogram")plot_ly(iris, y = ~Petal.Length, color = ~Species, type = "box")terrain1 <- matrix(rnorm(100*100), nrow = 100, ncol = 100)
plot_ly(z = ~terrain1, type = "heatmap")terrain2 <- matrix(sort(rnorm(100*100)), nrow = 100, ncol = 100)
plot_ly(z = ~terrain2, type = "surface")# Create data frame
state_pop <- data.frame(State = state.abb, Pop = as.vector(state.x77[,1]))
# Create hover text
state_pop$hover <- with(state_pop, paste(State, '<br>', "Population:", Pop))
# Make state borders white
borders <- list(color = toRGB("red"))
# Set up some mapping options
map_options <- list(
scope = 'usa',
projection = list(type = 'albers usa'),
showlakes = TRUE,
lakecolor = toRGB('white')
)
plot_ly(z = ~state_pop$Pop, text = ~state_pop$hover, locations = ~state_pop$State,
type = 'choropleth', locationmode = 'USA-states',
color = state_pop$Pop, colors = 'Blues', marker = list(line = borders)) %>%
layout(title = 'US Population in 1975', geo = map_options)library(ggplot2)
set.seed(100)
d <- diamonds[sample(nrow(diamonds), 1000), ]
p <- ggplot(data = d, aes(x = carat, y = price)) +
geom_point(aes(text = paste("Clarity:", clarity))) +
geom_smooth(aes(colour = cut, fill = cut)) + facet_wrap(~ cut)
gg <- ggplotly(p)
gg# posting to plot.ly (make sure you have set the authentication)
# (can be saved in Rprofile.site)
# Sys.setenv("plotly_username"="your_plotly_username")
# Sys.setenv("plotly_api_key"="your_api_key")
r <- api_create(gg)
r$organize_view_url.Rmd file)
.Rmd file)
---
title: "Air Quality"
author: "JHU"
date: "May 17, 2016"
output: html_document
---
output line in the YAML header, or by selecting an output from the Knit button’s pull-down menu.output: ioslides_presentationoutput: slidy_presentationoutput: beamer_presentation
## Insert Title Here***### Subheading or #### Smaller Subheading- bullet point+ sub-point1. first point or a) sub-sub-point>- iterated bullet point| Text | Code in R Markdown |
|---|---|
| plain text | plain text |
| italics | *italics* |
| bold | **bold** |
| link | [link](http://www.jhsph.edu) |
verbatim code |
\code here\ |
```{r}
head(airquality)
```
echo=FALSE in the chunk options (This can be useful for showing plots)
```{r, echo=FALSE}
head(airquality)
```
eval=FALSE in the chunk options
```{r, eval=FALSE}
head(airquality)
```
include=FALSE in the chunk options
```{r, include=FALSE}
head(airquality)
```
comment="" in the chunk options to get rid of it
```{r, comment=""}
head(airquality)
```
it allows you to create your own leaflet maps without needing to know any Javascript!
leaflet() = creates a map widget%>%) just like in dplyraddTiles() = adds mapping data from Open Street Map%>% addProviderTiles(providers$OpenStreetMap) library(leaflet)
my_map <- leaflet() %>%
# use the following instead of addTiles()
addProviderTiles(providers$OpenStreetMap)
# addTiles()
my_mapaddMarkers() = adds markers to your map one at a time by specifying the longitude and latitude
popup = argument that specifies the popup text when clicking on the markermy_map <- leaflet() %>%
addTiles() %>%
addMarkers(lat=39.2980803, lng=-76.5898801,
popup="Jeff Leek's Office")
my_mapset.seed(2016-04-25)
df <- data.frame(lat = runif(20, min = 39.2, max = 39.3),
lng = runif(20, min = -76.6, max = -76.5))
df %>%
leaflet() %>%
addTiles() %>%
addMarkers().png fileshopkinsIcon <- makeIcon(
iconUrl = "http://brand.jhu.edu/content/uploads/2014/06/university.shield.small_.blue_.png",
iconWidth = 31*215/230, iconHeight = 31,
iconAnchorX = 31*215/230/2, iconAnchorY = 16
)
hopkinsLatLong <- data.frame(
lat = c(39.2973166, 39.3288851, 39.2906617, 39.2970681, 39.2824806),
lng = c(-76.5929798, -76.6206598, -76.5469683, -76.6150537, -76.6016766))
hopkinsSites <- c(
"<a href='http://www.jhsph.edu/'>East Baltimore Campus</a>",
"<a href='https://apply.jhu.edu/visit/homewood/'>Homewood Campus</a>",
"<a href='http://www.hopkinsmedicine.org/johns_hopkins_bayview/'>Bayview Medical Center</a>",
"<a href='http://www.peabody.jhu.edu/'>Peabody Institute</a>",
"<a href='http://carey.jhu.edu/'>Carey Business School</a>"
)
hopkinsLatLong %>%
leaflet() %>%
addTiles() %>%
addMarkers(icon = hopkinsIcon, popup = hopkinsSites)addMarkers(clusterOptions = markerClusterOptions())df <- data.frame(lat = runif(500, min = 39.25, max = 39.35),
lng = runif(500, min = -76.65, max = -76.55))
df %>%
leaflet() %>%
addTiles() %>%
addMarkers(clusterOptions = markerClusterOptions())addCircleMarkers() = add circle markersdf <- data.frame(lat = runif(20, min = 39.25, max = 39.35),
lng = runif(20, min = -76.65, max = -76.55))
df %>%
leaflet() %>%
addTiles() %>%
addCircleMarkers()md_cities <- data.frame(name = c("Baltimore", "Frederick", "Rockville", "Gaithersburg",
"Bowie", "Hagerstown", "Annapolis", "College Park", "Salisbury", "Laurel"),
pop = c(619493, 66169, 62334, 61045, 55232,
39890, 38880, 30587, 30484, 25346),
lat = c(39.2920592, 39.4143921, 39.0840, 39.1434,
39.0068, 39.6418, 38.9784, 38.9897, 38.3607, 39.0993),
lng = c(-76.6077852, -77.4204875, -77.1528, -77.2014,
-76.7791, -77.7200, -76.4922, -76.9378, -75.5994, -76.8483))
md_cities %>%
leaflet() %>%
addTiles() %>%
addCircles(weight = 4, radius = sqrt(md_cities$pop) * 30)leaflet() %>%
addTiles() %>%
addRectangles(lat1 = 37.3858, lng1 = -122.0595,
lat2 = 37.3890, lng2 = -122.0625)df <- data.frame(lat = runif(20, min = 39.25, max = 39.35),
lng = runif(20, min = -76.65, max = -76.55),
col = sample(c("red", "blue", "green"), 20, replace = TRUE),
stringsAsFactors = FALSE)
df %>%
leaflet() %>%
addTiles() %>%
addCircleMarkers(color = df$col) %>%
addLegend(labels = LETTERS[1:3], colors = c("blue", "red", "green"))final products are HTML files, which can be viewed with any web browser and shared easily
devtools package installed in Rinstall_github('slidify', 'ramnathv'); install_github('slidifyLibraries', 'ramnathv') to install the slidify packageslibrary(slidify)setwd("~/project")author("title") = sets up initial files for a new slidify project (performs the following things)
title (or any name you typed) directory is created inside the current working directoryassets subdirectory and a file named index.Rmd are created inside title directoryassets subdirectory is populated with the following empty folders:
cssimgjslayoutsindex.Rmd R Markdown file will open up in RStudioslidify("index.Rmd") = processes the R Markdown file into a HTML page and imports all necessary librarieslibrary(knitr); browseURL("index.html") = opens up the built-in web browser in R Studio and displays the slidify presentation
field : value # comment
title = title of documentsubtitle = subtitle of documentauthor = author of documentjob = occupation of author (can be left blank)framework = controls formatting, usually the name of a library is used (i.e. io2012)
highlighter = controls effects for presentation (i.e highlight.js)hitheme = specifies theme of code (i.e. tomorrow)widgets = loads additional libraries to display LaTeX math equations(mathjax), quiz-styles components (quiz), and additional style (bootstrap = Twitter-created style)
$expresion$ for inline expressions, and $$expression$$ for block equationsmode = selfcontained/standalone/draft = depending whether the presentation will be given with Internet access or not
standalone = all the JavaScript libraries will be save locally so that the presentation can be executed without Internet accessselfcontained = load all JavaScript library at time of presentationlogo = displays a logo in title slideurl = specify path to assets/other folders that are used in the presentation
../ signifies the parent directory ---
title : Slidify
subtitle : Data meets presentation
author : Jeffrey Leek, Assistant Professor of Biostatistics
job : Johns Hopkins Bloomberg School of Public Health
logo : bloomberg_shield.png
framework : io2012 # {io2012, html5slides, shower, dzslides, ...}
highlighter : highlight.js # {highlight.js, prettify, highlight}
hitheme : tomorrow #
url:
lib: ../../libraries
assets: ../../assets
widgets : [mathjax] # {mathjax, quiz, bootstrap}
mode : selfcontained # {standalone, draft}
---## = signifies the title of the slide \(\rightarrow\) equivalent of h1 element in HTML--- = marks the end of a slide.class #id = assigns class and id attributes (CSS) to the slide and can be used to customize the style of the pageindex.Rmd file and most of the time it should function correctly--- &radio before slide content for multiple choice (make sure quiz is included in widgets)## = signifies title of questions1. a, 2. b, etc.)
2. _b_)*** .hint = denotes the hint that will be displayed when the user clicks on Show Hint button*** .explanation = denotes the explanation that will be displayed when the user clicks on Show Answer buttonslidify
--- &radio
# Question 1
What is 1 + 1?
1. 1
2. _2_
3. 3
4. 4
*** .hint
This is a hint
*** .explanation
This is an explanationknit HTML button can be used to generate previews for the presentation as wellpublish_github("user", "repo") can be used to publish the slidify document on to your on-line repo.Rpres file \(\rightarrow\) converted to .md file \(\rightarrow\) .html filealt-f + f + p)class: classname = specify slide-specific control from CSScss: file.css = can be used to import an external CSS file
transition property (similar to YAML) can be specified to control the transition between the previous and current slidestransition: linear = creates 2D linear transition (html5) between slidestransition: rotate = creates 3D rotating transition (html5) between slidestype can be added to specify the appearance of the slide (“slide type”)type: section and type: sub-section = distinct background and font colors, slightly larger heading text, appear at a different indent level within the slide navigation menutype: prompt and type: alert = distinct background color to communicate to viewers that the slide has different intent*** in between two sections of content on a slide to separate it into two columnsleft: 70% can be used to specify the proportions of each columnright: 30% works similarlyfont-family: fontname = changes the font of slide (specified in the same way as HTML)font-import: http://fonts.googleapis.com/css?family=Risque = imports font
.reveal to work (.reveal section del applies to any text enclosed by ~~text~~) .Rmd fileIntro: An R Package is a form of data product. In creating an R package, you’ve created polished, documented software for your users. This is a big step over just distributing functions or code that do a task.
install.packages()devtools::install_github() from devtools packagefairly easily maintained with proper documentation
R/ sub-directoryman/ sub-directorylibrary(name) to load the package)M.m-p format, “majorNumber.minorNumber-patchLevel”)gpclib
R/ sub-directoryexport("<function>") = export a functionimport("<package>") = import a packageimportFrom("<package>", "<function>") = import specific function from a packageexportClasses("<class>") = indicate the new types of S4 (4th version of S) classes created with the package (objects of the specified class can be created)exportMethods("<generic>") = methods that can operate on the new class objectsgpclib package# read.polyfile/write.polyfile are functions available to user
export("read.polyfile", "write.polyfile")
# import plot function from graphics package
importFrom(graphics, plot)
# gpc.poly/gpc.poly.nohole classes can be created by the user
exportClasses("gpc.poly", "gpc.poly.nohole")
# the listed methods can be applied to the gpc.poly/gpc.poly.nohole classes
exportMethods("show", "get.bbox", "plot", "intersect", "union", "setdiff",
"[", "append.poly", "scale.poly", "area.poly", "get.pts",
"coerce", "tristrip", "triangulate").Rd) should be placed in the man/ sub-directoryconcepts/package/datasets overview can also be documented
\name{} = name of function\alias{} = anything listed as alias will bring up the help file (?line is the same as ?residuals.tukeyline)
\title{} = full title of the function\description{} = full description of the purpose of function\usage{} = format/syntax of function\arguments{} = explanation of the arguments in the syntax of function\details{} = notes/details about limitation/features of the function\value{} = specifies what object is returned\reference{} = references for the function (paper/book from which the method is created)Help File Example: line function
\name{line}
\alias{line}
\alias{residuals.tukeyline}
\title{Robust Line Fitting}
\description{
Fit a line robustly as recommended in \emph{Exploratory Data Analysis}.
}
\usage{
line(x, y)
}
\arguments{
\item{x, y}{the arguments can be any way of specifying x-y pairs. See
\code{\link{xy.coords}}.}
}
\details{
Cases with missing values are omitted.
Long vectors are not supported.
}
\value{
An object of class \code{"tukeyline"}.
Methods are available for the generic functions \code{coef},
\code{residuals}, \code{fitted}, and \code{print}.
}
\references{
Tukey, J. W. (1977).
\emph{Exploratory Data Analysis},
Reading Massachusetts: Addison-Wesley.
}.tar.gz)system() function
system("R CMD build newpackage")system("R CMD check newpackage")package.skeleton() function in the utils package = creates a “skeleton” R package
R/, man/), DESCRIPTION file, NAMESPACE file, documentation filesR/ directoryman/ directoryR/ and man/ sub-directories (or just use package.skeleton())R/ sub-directoryman/ sub-directorytopten function.R script and add documentation directly to the script
#' = denotes the beginning of documentation
#' on the subsequent lines as you type or complete sections@param x definition = format of the documentation for the arguments
x = argument name (formatted in code format when processed to differentiate from definition)definiton = explanation of the what x represents@author = author of the function@details = detailed description of the function and its purpose@seealso = links to relevant functions used in creating the current function that may be of interest to the user@import package function = imports specific function from specified package@export = denotes that this function is exported for public use@return = specifies what is returned by the method#' Building a Model with Top Ten Features
#'
#' This function develops a prediction algorithm based on the top 10 features
#' in 'x' that are most predictive of 'y'.
#'
#' @param x a n x p matrix of n observations and p predictors
#' @param y a vector of length n representing the response
#' @return a 'lm' object representing the linear model with the top 10 predictors
#' @author Roger Peng
#' @details
#' This function runs a univariate regression of y on each predictor in x and
#' calculates the p-value indicating the significance of the association. The
#' final set of 10 predictors is the taken from the 10 smallest p-values.
#' @seealso \code{lm}
#' @export
#' @importFrom stats lm
topten <- function(x, y) {
p <- ncol(x)
if(p < 10)
stop("there are less than 10 predictors")
pvalues <- numeric(p)
for(i in seq_len(p)) {
fit <- lm(y ~ x[, i])
summ <- summary(fit)
pvalues[i] <- summ$coefficients[2, 4]
}
ord <- order(pvalues)
ord <- ord[1:10]
x10 <- x[, ord]
fit <- lm(y ~ x10)
coef(fit)
}
#' Prediction with Top Ten Features
#'
#' This function takes a set coefficients produced by the \code{topten}
#' function and makes a prediction for each of the values provided in the
#' input 'X' matrix.
#'
#' @param X a n x 10 matrix containing n observations
#' @param b a vector of coefficients obtained from the \code{topten} function
#' @return a numeric vector containing the predicted values
#' @export
predict10 <- function(X, b) {
X <- cbind(1, X)
drop(X %*% b)
}OOP structure in R is structured differently than most of the other languages
methods package (loaded by default)setClass() function in methods packageclass() function
numeric = number data, can be vectors as well (series of numbers)logical = TRUE, FALSE, NA
character = string of characterslm = linear model class, output from a linear modelnew()getS3method(<genericFunction>, <class>) = returns code for S3 method for a given class
mean.default)getMethod(<genericFunction>, <signature/class>) = returns code for S4 method for a given class
plot, mean, predict, print)
plot) will return the content of the function methods("mean") = returns methods associated with S3 generic functionshowMethods("show") = returns methods associated with S4 generic function
show is equivalent of print, but generally not called directly as objects are auto-printed as new data types and concepts are created, classes/methods provide a way for you to develop an intuitive interface to those data/concepts for users
Note: ?Classes, ?Methods, ?setClass, ?setMethod, and ?setGeneric contains very helpful documentation
Example: S3 Class/Method
# S3 method: mean
mean## function (x, ...)
## UseMethod("mean")
## <bytecode: 0x55cf40144310>
## <environment: namespace:base>
# associated methods
methods("mean")## [1] mean.Date mean.default mean.difftime mean.IDate* mean.POSIXct
## [6] mean.POSIXlt
## see '?methods' for accessing help and source code
# code for mean (first 10 lines)
# note: no specific function got numeric class, so default function for "mean" is used
# look at the default method for the mean function by using the getS3method function
head(getS3method("mean", "default"), 10)##
## 1 function (x, trim = 0, na.rm = FALSE, ...)
## 2 {
## 3 if (!is.numeric(x) && !is.complex(x) && !is.logical(x)) {
## 4 warning("argument is not numeric or logical: returning NA")
## 5 return(NA_real_)
## 6 }
## 7 if (na.rm)
## 8 x <- x[!is.na(x)]
## 9 if (!is.numeric(trim) || length(trim) != 1L)
## 10 stop("'trim' must be numeric of length one")
data.frame where each column can be an object of a different classsapply over the columns and call the mean functionmean chechs the class of the object and dispatches the appropriate methodnumeric column and an integer column; mean calls the default method for bothset.seed(3)
df <- data.frame(x = rnorm(100), y = 1:100)
sapply(df, mean)plot
plot function is generic and its behavior depends on the object being plottedpar(mfrow = c(1,2))
set.seed(10)
x <- rnorm(100)
plot(x)
# different from above
set.seed(10)
x <- rnorm(100)
x <- as.ts(x) # Convert to a time series object
plot(x)# S4 method: show
show## standardGeneric for "show" defined from package "methods"
##
## function (object)
## standardGeneric("show")
## <bytecode: 0x55cf3bccb9e0>
## <environment: 0x55cf3a90cc80>
## Methods may be defined for arguments: object
## Use showMethods("show") for currently available ones.
## (This generic function excludes non-simple inheritance; see ?setIs)
# associated methods
showMethods("show")## Function: show (package methods)
## object="ANY"
## object="C++Class"
## object="C++Function"
## object="C++Object"
## object="classGeneratorFunction"
## object="classRepresentation"
## object="color"
## object="envRefClass"
## object="externalRefMethod"
## object="function"
## (inherited from: object="ANY")
## object="genericFunction"
## object="genericFunctionWithTrace"
## object="MethodDefinition"
## object="MethodDefinitionWithTrace"
## object="MethodSelectionReport"
## object="MethodWithNext"
## object="MethodWithNextWithTrace"
## object="Module"
## object="namedList"
## object="ObjectsWithPackage"
## object="oldClass"
## object="refClassRepresentation"
## object="refMethodDef"
## object="refObjectGenerator"
## object="signature"
## object="sourceEnvironment"
## object="standardGeneric"
## (inherited from: object="genericFunction")
## object="traceable"
print)methods = extend generic functions to specify the behavior of generic functions on new classes
setClass() = function to create new class
setMethod() = define methods for class
@ is used to access the slots/attributes of the classsetMethod you need to specify a generic function (eg. plot) and a signatureshowClass() = displays definition/information about classprint show, summary, and plot should be writtenploygon class with set of (x, y) coordinates with setClass()plot function with setMethod()# load methods library
library(methods)
# create polygon class with x and y coordinates as slots
setClass("polygon", representation(x = "numeric", y = "numeric"))
# create plot method for ploygon class (ploygon = signature in this case)
setMethod("plot", "polygon",
# x is the polygon object, y is not needed in the function
function(x, y, ...) {
# notice that the slots of the polygon are accessed with the @ operator
plot(x@x, x@y, type = "n", ...)
# plots lines between all (x, y) pairs
# x@x[1] is added at the end because we need
# to connect the last point of polygon to the first
xp <- c(x@x, x@x[1])
yp <- c(x@y, x@y[1])
lines(xp, yp)
})## [1] "plot"
# print polygon method
# notice that the signature for class polygon is listed
# the ANY is the default method and it is what is called what no other signature matches
showMethods("plot")## Function: plot (package graphics)
## x="ANY"
## x="color"
## x="polygon"
# create a object of the newly created polygon class and plot
p <- new("polygon", x = c(1,2,3,4), y = c(1,2.5,3,1))
plot(p)swirlify which is designed to help you write a swirl courseCreate a lesson using the Shiny lesson authoring app
swirlify("Lesson 1", "My First Course")Create a lesson using the R console
new_lesson() function to create the coursenew_lesson("My First Lesson", "My First Course")My_First_Course
- My_First_Lesson
- lesson.yaml
- initLesson.R
- dependson.txt
- customTests.R
./My_First_Course/My_First_Lesson:
lesson.yaml is where you will write all of the questions for this lessoninitLesson.R is an R script that is run before the lesson starts which is usually used to load data or set up environmental variables.dependson.txt is the list of R packages your lesson will require. Swirl will install these packages if the user doesn’t already have them installed.customTests.R is where you can write your own tests for student’s answers.lesson.yaml file which structures the text that the student will see inside the R console while they are using swirl.
lesson.yaml file contains a sequence of questions that students will be prompted withlesson.yaml is always the meta question which contains general information about the course. Below is an example of the meta question:- Class: meta
Course: My Course
Lesson: My Lesson
Author: Dr. Jennifer Bryan
Type: Standard
Organization: The University of British Columbia
Version: 2.5
Class that specifies that question’s behavior inside of swirl.class is a set of key-value pairs that will be used to render the question when a student is using swirl.- Class: [type of question]
Key1: [value1]
Key2: [value2]
- Class: [type of question]
Key1: [value1]
Key2: [value2]
...
wq_message()- Class: text
Output: Welcome to my first swirl course!
| Welcome to my first swirl course!
...
CorrectAnswer is entered into the console if the student uses the skip() functionHint is displayed to the student if they don’t get the question rightAnswerTests determine whether or not the student answered the question correctlywq_command().- Class: cmd_question
Output: Add 2 and 2 together using the addition operator.
CorrectAnswer: 2 + 2
AnswerTests: omnitest(correctExpr='2 + 2')
Hint: Just type 2 + 2.
| Add 2 and 2 together using the addition operator.
>
AnswerChoices should be a semicolon separated string of choices that the student will have to choose from.wq_multiple().- Class: mult_question
Output: What is the capital of Canada?
AnswerChoices: Toronto;Montreal;Ottawa;Vancouver
CorrectAnswer: Ottawa
AnswerTests: omnitest(correctVal='Ottawa')
Hint: This city contains the Rideau Canal.
| What is the capital of Canada?
1: Toronto
2: Montreal
3: Ottawa
4: Vancouver
test_lesson() runs basic tests on all questions in the current lesson.demo_lesson() jumps right in to the current swirl lesson without needing to navigate swirl’s menusget_current_lesson() prints the current lesson and course that you are working on to the console- Class: meta
Course: My First Course
Lesson: Lesson 2
Author: your name goes here
Type: Standard
Organization: your organization's name goes here
Version: 2.4.3
- Class: mult_question
Output: Which of these shapes has four sides?
AnswerChoices: Square;Circle;Hexagon
CorrectAnswer: Square
AnswerTests: omnitest(correctVal= 'Square')
Hint: You should know this!
- Class: figure
Output: This is a simple graph.
Figure: fig1.R
FigureType: new
- Class: figure
Output: I added a line!
Figure: fig2.R
FigureType: add
My_First_Course
- My_First_Lesson
- lesson.yaml
- initLesson.R
- dependson.txt
- customTests.R
- My_Second_Lesson
- lesson.yaml
- initLesson.R
- dependson.txt
- customTests.R
My_First_Course will be displayed to the student as a lesson they can selectMANIFEST file to your course.
add_to_manifest() function, which will add the lesson you are currently working on to the MANIFESTMANIFEST yourself in a text editor.MANIFEST file below belongs to Team swirl’s R Programming course:Basic_Building_Blocks
Workspace_and_Files
Sequences_of_Numbers
Vectors
Missing_Values
Subsetting_Vectors
Matrices_and_Data_Frames